#include <stdio.h>
#include <stdlib.h>
#include <check.h>
#include "traducteur_message_test.h"
#include "../../interface/messqueue.h"
#include "../../messages/traducteur_message.h"

START_TEST (serialiser_message_au) {
    message_t message;
    message.type = AU;
    char * message_texte = serialiser_message(message);
    fail_unless(strcmp(message_texte, "0\n") == 0,
            "Message sérialisé d'arret d'urgence invalide");
    free(message_texte);
}
END_TEST

START_TEST (serialiser_message_go) {
    message_t message;
    message.type = GO;
    message.params[0] = 1;
    char * message_texte = serialiser_message(message);
    fail_unless(strcmp(message_texte, "102 1\n") == 0,
            "Message sérialisé de lancement de la production invalide");
    free(message_texte);
}
END_TEST

START_TEST (serialiser_message_init) {
    message_t message = {
        INIT,
        {5, 10, 100, 143, 23, 3000, 4, 10, 100, 144, 33, 2000, 8008}
    };
    char * message_texte = serialiser_message(message);
    fail_unless(
            strcmp(message_texte, "101 5 10 100 143 23 3000 4 10 100 144 33 2000 8008\n") == 0,
            "Message sérialisé d'initialisation de la production invalide");
    free(message_texte);
}
END_TEST
    
START_TEST (serialiser_message_invalide) {
    message_t message;
    message.type = -1;
    char * message_texte = serialiser_message(message);
    fail_unless(message_texte == NULL, "Message invalide n'aurait pas du etre sérialisé");
}
END_TEST

START_TEST (deserialiser_message_errpiece) {
    message_t attendu;
    attendu.type = ERRPIECE;
    message_t message = deserialiser_message("1");
    fail_unless(messages_egaux(message, attendu),
            "Message désérialisé d'errpiece attendu ne correspond pas à ce qui a été reçu");
}
END_TEST
    
START_TEST (deserialiser_message_go) {
    message_t attendu;
    attendu.type = GO;
    attendu.params[0] = 0;
    message_t message = deserialiser_message("102 0");
    fail_unless(messages_egaux(message, attendu),
            "Message désérialisé de go attendu ne correspond pas à ce qui a été reçu");
}
END_TEST

START_TEST (deserialiser_message_invalide_1) {
    message_t message = deserialiser_message("plop");
    fail_unless(message.type == -1, "Message de type -1 (invalide) attendu");
}
END_TEST

START_TEST (deserialiser_message_invalide_2) {
    message_t message = deserialiser_message("102 plop");
    fail_unless(message.type == -1, "Message de type -1 (invalide) attendu");
}
END_TEST

START_TEST (egalite_message_idem) {
    message_t message;
    message.type = ARRET;
    fail_unless(messages_egaux(message, message), "Message n'est pas égal à lui-même");
}
END_TEST
    
START_TEST (egalite_message_differents) {
    message_t m1, m2;
    m1.type = ARRET;
    m2.type = ARRET;
    fail_unless(messages_egaux(m1, m2), "Egalité messages : m1 n'est pas égal à m2");
}
END_TEST

START_TEST (inegalite_messages_type) {
    message_t m1, m2;
    m1.type = ARRET;
    m2.type = ARRDEG;
    fail_if(messages_egaux(m1, m2), "Inégalité messages : m1 (ARRET) est égal à m2 (ARRDEG)");
}
END_TEST

START_TEST (inegalite_messages_params) {
    message_t m1, m2;
    m1.type = GO;
    m1.params[0] = 0;
    m2.type = GO;
    m2.params[0] = 1;
    fail_if(messages_egaux(m1, m2),
            "Inégalité messages : m1 (GO, type A) est égal à m2 (GO, type B)");
}
END_TEST

Suite * message_suite(void) {
    Suite *s = suite_create("Messages");
    /* Egalité de messages test case */
    TCase *tc_egalite = tcase_create("Egalité");
    tcase_add_test(tc_egalite, egalite_message_idem);
    tcase_add_test(tc_egalite, egalite_message_differents);
    tcase_add_test(tc_egalite, inegalite_messages_type);
    tcase_add_test(tc_egalite, inegalite_messages_params);
    suite_add_tcase(s, tc_egalite);
    /* Serialiseur test case */
    TCase *tc_serialiseur = tcase_create("Serialiseur");
    tcase_add_test(tc_serialiseur, serialiser_message_au);
    tcase_add_test(tc_serialiseur, serialiser_message_go);
    tcase_add_test(tc_serialiseur, serialiser_message_init);
    tcase_add_test(tc_serialiseur, serialiser_message_invalide);
    suite_add_tcase(s, tc_serialiseur);
    /* Désérialiseur test case */
    TCase *tc_deserialiseur = tcase_create("Deserialiseur");
    tcase_add_test(tc_deserialiseur, deserialiser_message_errpiece);
    tcase_add_test(tc_deserialiseur, deserialiser_message_go);
    tcase_add_test(tc_deserialiseur, deserialiser_message_invalide_1);
    tcase_add_test(tc_deserialiseur, deserialiser_message_invalide_2);
    suite_add_tcase(s, tc_deserialiseur);

    return s;
}
